﻿package com.crawler.util;

import java.awt.Desktop;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.math.BigDecimal;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;

/**
 * 文件操作类，增、删、改、写、读
 * 
 * @author wzw
 */
public class FileUtil {
	/**
	 * 私有构造方法，防止类的实例化，因为工具类不需要实例化。
	 */
	public FileUtil() {

	}

	/**
	 * 写文本到指定文件
	 * 
	 * @param path
	 * @param str
	 */
	public static void writerTxt(String path, String str) {
		BufferedWriter fw = null;
		try {
			File file = new File(path);
			if (!FileUtil.isFileExist(path)) {
				FileUtil.makeDirectory(path);
			}
			fw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8")); // 指定编码格式，以免读取时中文字符异常
			fw.append(str);
			fw.newLine();
			fw.flush(); // 全部写入缓存中的内容
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 写文本到指定文件
	 * 
	 * @param path
	 * @param str
	 */
	public static void writerTxt(String path, String str, String encode) {
		BufferedWriter fw = null;
		try {
			File file = new File(path);
			if (!FileUtil.isFileExist(path)) {
				FileUtil.makeDirectory(path);
			}
			fw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), encode)); // 指定编码格式，以免读取时中文字符异常
			fw.append(str);
			fw.newLine();
			fw.flush(); // 全部写入缓存中的内容
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 启动关联应用程序来打开文件。 如果指定的文件是一个目录，则启动当前平台的文件管理器打开它。
	 * 
	 * @param fileName
	 *            文件路径
	 * @throws IOException
	 *             如果指定文件没有关联应用程序，或者关联应用程序无法启动
	 */
	public static void openFile(File fileName) throws IOException {
		Desktop desktop = getDesktop();
		if (desktop != null) {
			if (desktop.isSupported(Desktop.Action.OPEN)) {
				desktop.open(fileName);
			} else {
				throw new IOException("当前平台不支持该open的Action动作!");
			}
		} else {
			throw new IOException("当前平台不支持此类(Desktop)!");
		}
	}

	/**
	 * 返回当前浏览器上下文的 Desktop 实例。一些平台不支持 Desktop API <br>
	 * 可以使用 isDesktopSupported() 方法来确定是否支持当前桌面。
	 * 
	 * @return 返回当前浏览器上下文的 Desktop 实例
	 */
	protected static Desktop getDesktop() {
		if (Desktop.isDesktopSupported()) {
			return Desktop.getDesktop();
		}
		return null;
	}

	/**
	 * 修改文件的最后访问时间。 如果文件不存在则创建该文件。
	 * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
	 * 
	 * @param file
	 *            需要修改最后访问时间的文件。
	 * @since 1.0
	 */
	public static void touch(File file) {
		long currentTime = System.currentTimeMillis();
		if (!file.exists()) {
			System.err.println("file not found:" + file.getName());
			System.err.println("Create a new file:" + file.getName());
			try {
				if (file.createNewFile()) {
					System.out.println("Succeeded!");
				} else {
					System.err.println("Create file failed!");
				}
			} catch (IOException e) {
				System.err.println("Create file failed!");
				e.printStackTrace();
			}
		}
		boolean result = file.setLastModified(currentTime);
		if (!result) {
			System.err.println("touch failed: " + file.getName());
		}
	}

	/**
	 * 修改文件的最后访问时间。 如果文件不存在则创建该文件。
	 * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
	 * 
	 * @param fileName
	 *            需要修改最后访问时间的文件的文件名。
	 * @since 1.0
	 */
	public static void touch(String fileName) {
		File file = new File(fileName);
		touch(file);
	}

	/**
	 * 修改文件的最后访问时间。 如果文件不存在则创建该文件。
	 * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
	 * 
	 * @param files
	 *            需要修改最后访问时间的文件数组。
	 * @since 1.0
	 */
	public static void touch(File[] files) {
		for (int i = 0; i < files.length; i++) {
			touch(files[i]);
		}
	}

	/**
	 * 修改文件的最后访问时间。 如果文件不存在则创建该文件。
	 * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考虑中。</b>
	 * 
	 * @param fileNames
	 *            需要修改最后访问时间的文件名数组。
	 * @since 1.0
	 */
	public static void touch(String[] fileNames) {
		File[] files = new File[fileNames.length];
		for (int i = 0; i < fileNames.length; i++) {
			files[i] = new File(fileNames[i]);
		}
		touch(files);
	}

	/**
	 * 判断指定的文件是否存在。
	 * 
	 * @param fileName
	 *            要判断的文件的文件名
	 * @return 存在时返回true，否则返回false。
	 * @since 1.0
	 */
	public static boolean isFileExist(String fileName) {
		return new File(fileName).isFile();
	}

	/**
	 * 创建指定的目录。 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。 <b>注意：可能会在返回false的时候创建部分父目录。</b>
	 * 
	 * @param file
	 *            要创建的目录
	 * @return 完全创建成功时返回true，否则返回false。
	 * @since 1.0
	 */
	public static boolean makeDirectory(File file) {
		File parent = file.getParentFile();
		if (parent != null) {
			return parent.mkdirs();
		}
		return false;
	}

	/**
	 * 创建指定的目录。 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。 <b>注意：可能会在返回false的时候创建部分父目录。</b>
	 * 
	 * @param fileName
	 *            要创建的目录的目录名
	 * @return 完全创建成功时返回true，否则返回false。
	 * @since 1.0
	 */
	public static boolean makeDirectory(String fileName) {
		File file = new File(fileName);
		return makeDirectory(file);
	}

	/**
	 * 清空指定目录中的文件。 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
	 * 另外这个方法不会迭代删除，即不会删除子目录及其内容。
	 * 
	 * @param directory
	 *            要清空的目录
	 * @return 目录下的所有文件都被成功删除时返回true，否则返回false.
	 * @since 1.0
	 */
	public static boolean emptyDirectory(File directory) {
		boolean result = true;
		File[] entries = directory.listFiles();
		for (int i = 0; i < entries.length; i++) {
			if (!entries[i].delete()) {
				result = false;
			}
		}
		return result;
	}

	/**
	 * 清空指定目录中的文件。 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
	 * 另外这个方法不会迭代删除，即不会删除子目录及其内容。
	 * 
	 * @param directoryName
	 *            要清空的目录的目录名
	 * @return 目录下的所有文件都被成功删除时返回true，否则返回false。
	 * @since 1.0
	 */
	public static boolean emptyDirectory(String directoryName) {
		File dir = new File(directoryName);
		return emptyDirectory(dir);
	}

	/**
	 * 删除指定目录及其中的所有内容。
	 * 
	 * @param dirName
	 *            要删除的目录的目录名
	 * @return 删除成功时返回true，否则返回false。
	 * @since 1.0
	 */
	public static boolean deleteDirectory(String dirName) {
		return deleteDirectory(new File(dirName));
	}

	/**
	 * 删除指定目录及其中的所有内容。
	 * 
	 * @param dir
	 *            要删除的目录
	 * @return 删除成功时返回true，否则返回false。
	 * @since 1.0
	 */
	public static boolean deleteDirectory(File dir) {
		if ((dir == null) || !dir.isDirectory()) {
			throw new IllegalArgumentException("Argument " + dir + " is not a directory. ");
		}

		File[] entries = dir.listFiles();
		int sz = entries.length;

		for (int i = 0; i < sz; i++) {
			if (entries[i].isDirectory()) {
				if (!deleteDirectory(entries[i])) {
					return false;
				}
			} else {
				if (!entries[i].delete()) {
					return false;
				}
			}
		}

		if (!dir.delete()) {
			return false;
		}
		return true;
	}

	/**
	 * 返回文件的URL地址。
	 * 
	 * @param file
	 *            文件
	 * @return 文件对应的的URL地址
	 * @throws MalformedURLException
	 * @since 1.0
	 * @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。 请使用File.toURL方法。
	 */
	@Deprecated
	public static URL getURL(File file) throws MalformedURLException {
		String fileURL = "file:/" + file.getAbsolutePath();
		URL url = new URL(fileURL);
		return url;
	}

	/**
	 * 列出目录中的所有内容，包括其子目录中的内容。
	 * 
	 * @param fileName
	 *            要列出的目录的目录名
	 * @return 目录内容的文件数组。
	 * @since 1.0
	 */
	/*
	 * public static File[] listAll(String fileName) { return listAll(new
	 * File(fileName)); }
	 */

	/**
	 * 列出目录中的所有内容，包括其子目录中的内容。
	 * 
	 * @param file
	 *            要列出的目录
	 * @return 目录内容的文件数组。
	 * @since 1.0
	 */
	/*
	 * public static File[] listAll(File file) { ArrayList list = new
	 * ArrayList(); File[] files; if (!file.exists() || file.isFile()) { return
	 * null; } list(list, file, new AllFileFilter()); list.remove(file); files =
	 * new File[list.size()]; list.toArray(files); return files; }
	 */

	/**
	 * 从文件路径得到文件名。
	 * 
	 * @param filePath
	 *            文件的路径，可以是相对路径也可以是绝对路径
	 * @return 对应的文件名
	 * @since 1.0
	 */
	public static String getFileName(String filePath) {
		File file = new File(filePath);
		return file.getName();
	}

	/**
	 * 从文件名得到文件绝对路径。
	 * 
	 * @param fileName
	 *            文件名
	 * @return 对应的文件路径
	 * @since 1.0
	 */
	// public static String getFilePath(String fileName) {
	// File file = new File(fileName);
	// return file.getAbsolutePath();
	// }

	/**
	 * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
	 * 其实就是将路径中的"\"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，
	 * 某中程度上说"/"比"\"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。
	 * 
	 * @param filePath
	 *            转换前的路径
	 * @return 转换后的路径
	 * @since 1.0
	 */
	public static String toUNIXpath(String filePath) {
		return filePath.replace('\\', '/');
	}

	/**
	 * 从文件名得到UNIX风格的文件绝对路径。
	 * 
	 * @param fileName
	 *            文件名
	 * @return 对应的UNIX风格的文件路径
	 * @since 1.0
	 * @see #toUNIXpath(String filePath) toUNIXpath
	 */
	public static String getUNIXfilePath(String fileName) {
		File file = new File(fileName);
		return toUNIXpath(file.getAbsolutePath());
	}

	/**
	 * 得到文件的类型。 实际上就是得到文件名中最后一个“.”后面的部分。
	 * 
	 * @param fileName
	 *            文件名
	 * @return 文件名中的类型部分
	 * @since 1.0
	 */
	public static String getTypePart(String fileName) {
		int point = fileName.lastIndexOf('.');
		int length = fileName.length();
		if (point == -1 || point == length - 1) {
			return "";
		} else {
			return fileName.substring(point + 1, length);
		}
	}

	/**
	 * 得到文件的类型。 实际上就是得到文件名中最后一个“.”后面的部分。
	 * 
	 * @param file
	 *            文件
	 * @return 文件名中的类型部分
	 * @since 1.0
	 */
	public static String getFileType(File file) {
		return getTypePart(file.getName());
	}

	/**
	 * 得到文件的名字部分。 实际上就是路径中的最后一个路径分隔符后的部分。
	 * 
	 * @param fileName
	 *            文件名
	 * @return 文件名中的名字部分
	 * @since 1.0
	 */
	public static String getNamePart(String fileName) {
		int point = getPathLsatIndex(fileName);
		int length = fileName.length();
		if (point == -1) {
			return fileName;
		} else if (point == length - 1) {
			int secondPoint = getPathLsatIndex(fileName, point - 1);
			if (secondPoint == -1) {
				if (length == 1) {
					return fileName;
				} else {
					return fileName.substring(0, point);
				}
			} else {
				return fileName.substring(secondPoint + 1, point);
			}
		} else {
			return fileName.substring(point + 1);
		}
	}

	/**
	 * 得到文件名中的父路径部分。 对两种路径分隔符都有效。 不存在时返回""。
	 * 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。
	 * 
	 * @param fileName
	 *            文件名
	 * @return 父路径，不存在或者已经是父目录时返回""
	 * @since 1.0
	 */
	public static String getPathPart(String fileName) {
		int point = getPathLsatIndex(fileName);
		int length = fileName.length();
		if (point == -1) {
			return "";
		} else if (point == length - 1) {
			int secondPoint = getPathLsatIndex(fileName, point - 1);
			if (secondPoint == -1) {
				return "";
			} else {
				return fileName.substring(0, secondPoint);
			}
		} else {
			return fileName.substring(0, point);
		}
	}

	/**
	 * 得到路径分隔符在文件路径中首次出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
	 * 
	 * @param fileName
	 *            文件路径
	 * @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。
	 * @since 1.0
	 */
	public static int getPathIndex(String fileName) {
		int point = fileName.indexOf('/');
		if (point == -1) {
			point = fileName.indexOf('\\');
		}
		return point;
	}

	/**
	 * 得到路径分隔符在文件路径中指定位置后首次出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
	 * 
	 * @param fileName
	 *            文件路径
	 * @param fromIndex
	 *            开始查找的位置
	 * @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。
	 * @since 1.0
	 */
	public static int getPathIndex(String fileName, int fromIndex) {
		int point = fileName.indexOf('/', fromIndex);
		if (point == -1) {
			point = fileName.indexOf('\\', fromIndex);
		}
		return point;
	}

	/**
	 * 得到路径分隔符在文件路径中最后出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
	 * 
	 * @param fileName
	 *            文件路径
	 * @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。
	 * @since 1.0
	 */
	public static int getPathLsatIndex(String fileName) {
		int point = fileName.lastIndexOf('/');
		if (point == -1) {
			point = fileName.lastIndexOf('\\');
		}
		return point;
	}

	/**
	 * 得到路径分隔符在文件路径中指定位置前最后出现的位置。 对于DOS或者UNIX风格的分隔符都可以。
	 * 
	 * @param fileName
	 *            文件路径
	 * @param fromIndex
	 *            开始查找的位置
	 * @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。
	 * @since 1.0
	 */
	public static int getPathLsatIndex(String fileName, int fromIndex) {
		int point = fileName.lastIndexOf('/', fromIndex);
		if (point == -1) {
			point = fileName.lastIndexOf('\\', fromIndex);
		}
		return point;
	}

	/**
	 * 将文件名中的类型部分去掉。
	 * 
	 * @param filename
	 *            文件名
	 * @return 去掉类型部分的结果
	 * @since 1.0
	 */
	public static String trimType(String filename) {
		int index = filename.lastIndexOf(".");
		if (index != -1) {
			return filename.substring(0, index);
		} else {
			return filename;
		}
	}

	/**
	 * 得到相对路径。 文件名不是目录名的子节点时返回文件名。
	 * 
	 * @param pathName
	 *            目录名
	 * @param fileName
	 *            文件名
	 * @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名
	 * @since 1.0
	 */
	public static String getSubpath(String pathName, String fileName) {
		int index = fileName.indexOf(pathName);
		if (index != -1) {
			return fileName.substring(index + pathName.length() + 1);
		} else {
			return fileName;
		}
	}

	/**
	 * 检查给定目录的存在性 保证指定的路径可用，如果指定的路径不存在，那么建立该路径，可以为多级路径
	 * 
	 * @param path
	 * @return 真假值
	 * @since 1.0
	 */
	public static final boolean pathValidate(String path) {
		// String path="d:/web/www/sub";
		// System.out.println(path);
		// path = getUNIXfilePath(path);

		// path = ereg_replace("^\\/+", "", path);
		// path = ereg_replace("\\/+$", "", path);
		String[] arraypath = path.split("/");
		String tmppath = "";
		for (int i = 0; i < arraypath.length; i++) {
			tmppath += "/" + arraypath[i];
			File d = new File(tmppath.substring(1));
			if (!d.exists()) { // 检查Sub目录是否存在
				System.out.println(tmppath.substring(1));
				if (!d.mkdir()) {
					return false;
				}
			}
		}
		return true;
	}

	public static final List<String> getFileContentList(String path) throws IOException {
		List<String> a = new ArrayList<String>();
		try {
			File f = new File(path);
			if (f.exists()) {
				FileReader fr = new FileReader(path);
				BufferedReader br = new BufferedReader(fr); // 建立BufferedReader对象，并实例化为br
				String line = br.readLine(); // 从文件读取一行字符串
				// 判断读取到的字符串是否不为空
				while (line != null) {

					line = br.readLine(); // 从文件中继续读取一行数据
					a.add(line);
				}
				br.close(); // 关闭BufferedReader对象
				fr.close(); // 关闭文件
			}

		} catch (IOException e) {
			throw e;
		}
		return a;
	}

	/**
	 * 根据内容生成文件
	 * 
	 * @param path要生成文件的绝对路径
	 *            ，
	 * @param 文件的内容
	 *            。
	 * @return 真假值
	 * @since 1.0
	 */
	public static final boolean genModuleTpl(String path, String modulecontent) throws IOException {

		path = getUNIXfilePath(path);
		String[] patharray = path.split("\\/");
		String modulepath = "";
		for (int i = 0; i < patharray.length - 1; i++) {
			modulepath += "/" + patharray[i];
		}
		File d = new File(modulepath.substring(1));
		if (!d.exists()) {
			if (!pathValidate(modulepath.substring(1))) {
				return false;
			}
		}
		try {
			FileWriter fw = new FileWriter(path); // 建立FileWriter对象，并实例化fw
			// 将字符串写入文件
			fw.write(modulecontent);
			fw.close();
		} catch (IOException e) {
			throw e;
		}
		return true;
	}

	/**
	 * 获取图片文件的扩展名（发布系统专用）
	 * 
	 * @param picname
	 *            为图片名称加上前面的路径不包括扩展名
	 * @return 图片的扩展名
	 * @since 1.0
	 */
	public static final String getPicExtendName(String pic_path) {
		pic_path = getUNIXfilePath(pic_path);
		String pic_extend = "";
		if (isFileExist(pic_path + ".gif")) {
			pic_extend = ".gif";
		}
		if (isFileExist(pic_path + ".jpeg")) {
			pic_extend = ".jpeg";
		}
		if (isFileExist(pic_path + ".jpg")) {
			pic_extend = ".jpg";
		}
		if (isFileExist(pic_path + ".png")) {
			pic_extend = ".png";
		}
		return pic_extend; // 返回图片扩展名
	}

	// 拷贝文件
	public static final boolean CopyFile(File in, File out) throws Exception {
		try {
			FileInputStream fis = new FileInputStream(in);
			FileOutputStream fos = new FileOutputStream(out);
			byte[] buf = new byte[1024];
			int i = 0;
			while ((i = fis.read(buf)) != -1) {
				fos.write(buf, 0, i);
			}
			fis.close();
			fos.close();
			return true;
		} catch (IOException ie) {
			ie.printStackTrace();
			return false;
		}
	}

	// 拷贝文件
	public static final boolean CopyFile(String infile, String outfile) throws Exception {
		try {
			File in = new File(infile);
			File out = new File(outfile);
			return CopyFile(in, out);
		} catch (IOException ie) {
			ie.printStackTrace();
			return false;
		}

	}

	/**
	 * 获得程序根目录地址
	 * 
	 * @param filename
	 * @return
	 */
	public String getCurrentPath() {

		File a = new File(this.getClass().getResource("/").getFile());
		String defaultConfig = a.getParent();

		return defaultConfig;

	}

	public String getFilePath(String filename) {
		String path = FileUtil.class.getResource(filename).getFile();
		return path;
	}

	public InputStream getFileInputStream(String filePath) {
		InputStream is = this.getClass().getResourceAsStream(filePath);
		return is;
	}

	LineNumberReader a = null;

	/**
	 * 获取txt下指定行的值
	 * 
	 * @param path
	 * @param lineno
	 * @return
	 */
	public String getTaskUrl(String path, int lineno) {
		FileReader fr;
		String taskurl = null;
		try {
			fr = new FileReader(path);
			BufferedReader br = new BufferedReader(fr);
			if (a == null) {
				a = new LineNumberReader(br);
			}

			a.setLineNumber(lineno);
			taskurl = a.readLine();

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {

		}
		return taskurl;
	}

	/**
	 * 获取文件最后更新时间,如果没有获取到则默认为一年前的今天
	 * 
	 * @param path
	 * @return
	 * @throws IOException
	 */
	public static final Long getFileLastModifedStamp(String path) {
		Long time = 0L;

		try {
			if (!FileUtil.isFileExist(path)) {
				FileUtil.makeDirectory(path);
				FileUtil.writerTxt(path, "0");
				return time;
			}

			File file = new File(path);
			time = file.lastModified();
		} catch (Exception e) {
			time = 0L;
		}
		//
		// if(time==null || time==0){
		// Date lastdatenow=DateUtil.getNowDate();
		// lastdatenow=DateUtil.getDateBefore(lastdatenow,-365);
		// time=lastdatenow.getTime();
		// }
		//
		return time;
	}

	/**
	 * 修改文件最后更新时间
	 * 
	 * @param path
	 * @return
	 * @throws IOException
	 */
	public static final Boolean setFileLastModifedStamp(String path, Long time) {
		try {
			File file = new File(path);
			file.setLastModified(time);
			return true;
		} catch (Exception e) {
			return false;
		} finally {
		}

	}

	/**
	 * 
	 * 设置文件的最后修改时间和内容
	 * 
	 * @param path
	 * @param time
	 * @param content
	 *            评论的数量
	 * @return
	 */
	public static final Boolean setFileTimeAndContent(String path, Long time, String content) {
		try {
			File file = new File(path);
			file.setLastModified(time);

			// FileUtil.writerTxt(path,content);
			FileWriter fw = new FileWriter(file);
			fw.write(content);
			fw.flush();
			fw.close();
			return true;
		} catch (Exception e) {
			return false;
		} finally {
		}

	}

	/**
	 * 获取文件夹下的所有文件名
	 * 
	 * @param path
	 * @return
	 */
	public static List<String> getFileNames(String path) {
		List<String> list = null;
		File file = new File(path);
		File[] tempList = file.listFiles();
		if (tempList != null) {

			list = new ArrayList<String>();
			for (int i = 0; i < tempList.length; i++) {
				list.add(tempList[i].getName());
			}
		}
		return list;
	}

	/**
	 * 获得去除扩展名的文件名
	 * 
	 * @param oldFilename
	 * @return
	 */
	public static String removeExtension(String oldFilename) {
		final File oldFile = new File(oldFilename);
		final int iExtPos = oldFile.getName().lastIndexOf('.');
		if (iExtPos != -1) {
			final String parentPath = oldFilename.substring(0, oldFilename.length() - oldFile.getName().length());
			return parentPath + oldFile.getName().substring(0, iExtPos);
		}
		return oldFilename;
	}

	/**
	 * 剪切文件
	 * 
	 * @param sourceFile
	 * @param destFile
	 */
	public static void cutFile(File sourceFile, File destFile) {
		copyFile(sourceFile, destFile);
		sourceFile.delete();
	}

	/**
	 * 复制文件
	 * 
	 * @param sourceFile
	 * @param destFile
	 * @throws IOException
	 */
	public static void copyFile(File sourceFile, File destFile) {
		try {
			if (sourceFile.equals(destFile)) {
				return;
			}
			if (!destFile.getParentFile().exists() && !destFile.getParentFile().mkdirs()) {
				throw new IOException("Cannot create directory " + destFile.getParent());
			}
			final int BUFFER = 2048;
			BufferedInputStream source = new BufferedInputStream(new FileInputStream(sourceFile), BUFFER);
			try {
				BufferedOutputStream dest = new BufferedOutputStream(new FileOutputStream(destFile), BUFFER);
				try {
					int count;
					byte data[] = new byte[BUFFER];
					while ((count = source.read(data, 0, BUFFER)) != -1) {
						dest.write(data, 0, count);
					}
				} finally {
					FileUtil.close(dest);
				}
			} finally {
				FileUtil.close(source);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 删除子目录和子文件
	 * 
	 * @param directory
	 * @return
	 */
	public static boolean deleteChildren(File directory) {
		if (!directory.canRead())
			return false;
		File[] files = directory.listFiles();
		for (int i = 0; i < files.length; i++) {
			if (files[i].isDirectory()) {
				if (!deleteChildren(files[i]) || !files[i].delete()) {
					return false;
				}
			} else if (!files[i].delete()) {
				return false;
			}
		}
		return directory.delete();
	}

	/**
	 * 复制文件夹包括里面的文件
	 * 
	 * @param fromDirectory
	 * @param toDirectory
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public static void copyDirectory(File fromDirectory, File toDirectory) throws FileNotFoundException, IOException {
		if (!toDirectory.exists() && !toDirectory.mkdirs()) {
			throw new IllegalStateException("Cannot create directory " + toDirectory.getAbsolutePath());
		}
		File[] fromFiles = fromDirectory.listFiles();
		for (int i = 0; i < fromFiles.length; i++) {
			File toFile = new File(toDirectory, fromFiles[i].getName());
			if (fromFiles[i].isFile()) {
				copyFile(fromFiles[i], toFile);
			} else {
				copyDirectory(fromFiles[i], toFile);
			}
		}
	}

	/**
	 * 读取文件到stream
	 * 
	 * @param file
	 * @return
	 */
	public static byte[] readFileStream(File file) {
		return readFileStream(file.getAbsolutePath());
	}

	/**
	 * 读取文件到stream
	 * 
	 * @param path
	 * @return
	 */
	public static byte[] readFileStream(String path) {
		FileInputStream fis = null;
		byte[] bytes = null;
		try {
			fis = new FileInputStream(path);
			bytes = new byte[fis.available()];
			fis.read(bytes);
		} catch (Exception e) {
		} finally {
			FileUtil.close(fis);
		}
		return bytes;
	}

	/**
	 * 字节数组转换成输入流
	 * 
	 * @param buf
	 * @return
	 */
	public static InputStream byteArray2InputStream(byte[] buf) {
		return new ByteArrayInputStream(buf);
	}

	/**
	 * 输入流转byte数组
	 * 
	 * @param inputStream
	 * @return
	 * @throws IOException
	 */
	public static byte[] inputStream2ByteArray(InputStream inputStream) throws IOException {
		ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
		byte[] buff = new byte[100];
		int rc = 0;
		while ((rc = inputStream.read(buff, 0, 100)) > 0) {
			swapStream.write(buff, 0, rc);
		}
		byte[] in2b = swapStream.toByteArray();
		return in2b;
	}

	/**
	 * 读出文件到output
	 * 
	 * @param file
	 * @param output
	 * @throws IOException
	 */
	public static void readFile(File file, OutputStream output) throws IOException {
		FileInputStream input = null;
		FileChannel fc = null;
		try {
			input = new FileInputStream(file);
			fc = input.getChannel();
			ByteBuffer buffer = ByteBuffer.allocate(4096);
			for (;;) {
				buffer.clear();
				int n = fc.read(buffer);
				if (n == (-1))
					break;
				output.write(buffer.array(), 0, buffer.position());
			}
		} finally {
			FileUtil.close(fc);
			FileUtil.close(input);
		}
	}

	/**
	 * 查看文件件是否存在不存就创建
	 * 
	 * @param thisImageDir
	 */
	public static void mkdirs(String dir) {
		if (!(new File(dir).isDirectory())) {
			try {
				new File(dir).mkdirs();
			} catch (SecurityException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 写出文件
	 * 
	 * @param filePath
	 * @param _byte
	 */
	public static void writeFile(String filePath, byte[] _byte) {

		ByteArrayInputStream bais = new ByteArrayInputStream(_byte);
		try {
			writeFile(new File(filePath), bais);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			FileUtil.close(bais);
		}
	}

	/**
	 * 写出文件
	 * 
	 * @param file
	 * @param is
	 * @param encoding
	 */
	public static void writeFile(File file, InputStream is) {
		OutputStream os = null;
		try {
			os = new FileOutputStream(file);
			int size = is.available();
			for (int j = 0; j < size; j++) {
				os.write(is.read());
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			FileUtil.close(os);
			FileUtil.close(is);
		}
	}

	/**
	 * 获得文件大小
	 * 
	 * @param f
	 * @return
	 */
	public static long getFileSize(File f) {

		if (f == null || !f.exists())
			return 0;
		long s = 0;
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(f);
			s = fis.available();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			FileUtil.close(fis);
		}
		return s;
	}

	/**
	 * 获得文件的KB大小
	 * 
	 * @param f
	 * @return
	 */
	public static BigDecimal getKBFileSize(File f) {
		return BigDecimal.valueOf(getFileSize(f)).divide(BigDecimal.valueOf(1024)).setScale(2,
				BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 获得文件的MB大小
	 * 
	 * @param f
	 * @return
	 */
	public static BigDecimal getMBFileSize(File f) {
		return getKBFileSize(f).divide(BigDecimal.valueOf(1024)).setScale(2, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 获得文本的行数
	 * 
	 * @param file
	 * @return
	 */
	public static int getFileLines(File file) {
		int lines = 0;
		if (file.canRead()) {
			BufferedReader br = null;
			try {
				br = new BufferedReader(new FileReader(file));
				while (br.readLine() != null) {
					lines++;
				}
				br.close();
			} catch (FileNotFoundException e) {

				e.printStackTrace();
			} catch (IOException e) {

				e.printStackTrace();
			} finally {
				FileUtil.close(br);
			}
		}
		return lines;
	}

	/**
	 * 读取远程文件到本地
	 * 
	 * @param fileUrl
	 *            远程文件url 如：http://www.baidu.com/1.jpg
	 * @param localFilePath
	 *            本地硬盘绝对路径 c:/1.jpg
	 * @return
	 */
	public static boolean readDistanceFile(String fileUrl, String localFilePath) {
		java.io.BufferedInputStream bis = null;
		OutputStream bos = null;
		URL url = null;
		try {
			// 实例化url
			url = new URL(fileUrl);
			// 载入图片到输入流
			bis = new BufferedInputStream(url.openStream());
			// 实例化存储字节数组
			byte[] bytes = new byte[100];
			// 设置写入路径以及图片名称
			bos = new FileOutputStream(new File(localFilePath));
			int len;
			while ((len = bis.read(bytes)) > 0) {
				bos.write(bytes, 0, len);
			}
			return true;
		} catch (Exception e) {
			// 如果图片未找到
			return false;
		} finally {
			// 关闭输出流
			FileUtil.close(bis);
			FileUtil.close(bos);
		}

	}

	/**
	 * 关闭流
	 * 
	 * @param os
	 */
	public static void close(Closeable os) {
		if (os != null) {
			try {
				os.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void writeLogToTxt(String log, String fileurl) {
		String[] fileurl_cache = fileurl.split("/");
		String disc = "";
		for (int i = 0; i < fileurl_cache.length - 1; i++) {
			disc = disc + fileurl_cache[i] + "/";
		}
		File filedir = new File(disc);
		if (!(filedir.isDirectory())) {
			System.out.println("mkdir : "+filedir.getPath());
			filedir.mkdir();
		}
		try {
			File file = new File(fileurl);
			FileOutputStream fos = new FileOutputStream(file, true);
			OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
			BufferedWriter bw = new BufferedWriter(osw);
			bw.write(log);
			bw.newLine();
			bw.flush();
			bw.close();
			osw.close();
			fos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static String txt2String(File file) {
		String result = "";
		try {
			BufferedReader br = new BufferedReader(new FileReader(file));// 构造一个BufferedReader类来读取文件
			String s = null;
			while ((s = br.readLine()) != null) {// 使用readLine方法，一次读一行
				result = result + s;
			}
			br.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
}
